import type { FormInstance } from 'antd/lib/form';
import { ComparatorType } from '@/services/formList';

export interface PovNumAndStatus {
  expand: boolean;
  povRowNum: number;
  height: number;
  butPovLocationIndex: number;
  needToRefresh: boolean;
  refreshResetBtnIndex: number;
  isEqual?: boolean; // pov 是否正好一行能展示完
  isOverflow?: boolean; // pov是否超出一行
}
// pov筛选条件额外属性参数数据格式
export interface PovExtraAttribute {
  is: number;
  v: number;
  hierarchicalIdentification: boolean;
  leCon?: string;
  key?: string;
  // dataList?: PlsItem[];
  treeView?: boolean;
  [key: string]: any;
}
/**
 * 根据body的宽度获取一行pov的数量和一个pov所占的栅格数
 */
export const getTheNumberOfPovInARow = (bodyWidth: number | undefined) => {
  let numberOfPovInARow = 6;
  if (bodyWidth) {
    if (bodyWidth <= 520) {
      numberOfPovInARow = 1;
    } else if (bodyWidth <= 640) {
      numberOfPovInARow = 2;
    } else if (bodyWidth <= 860) {
      numberOfPovInARow = 3;
    } else if (bodyWidth <= 1366) {
      numberOfPovInARow = 4;
    }
  }
  return {
    numberOfPovInARow,
    colNumberOfGrids: Math.ceil(24 / numberOfPovInARow),
  };
};

/**
 * 开表的时候获取pov的每个表单默认值数据集合
 */
export const getPovInitValue = (pageList: any, listConfigData?: any) => {
  // 表单pov的初始化默认值
  const newInitPovValue: Record<string, unknown> = {};
  // 表单pov的额外属性
  const povExtraAttributes: {
    [key: number]: PovExtraAttribute;
  } = {};
  // povList：浮动行表pov数据
  // povDimensions:浮动行表维度pov对应拉平的下拉数据
  // smartList:浮动行表smartList pov对应的下拉所有数据
  const { povList } = listConfigData;
  povList.forEach((povItem: any) => {
    // defaultValue 当前pov的默认值
    // alias当前pov的别名也是唯一标识
    // valueType当前pov的类型
    // isGlobal:当前pov是否需要做全局联动
    let hierarchicalIdentification = false;
    const {
      valueTypeMap: { defaultValue, multipleLevelInfo, multiLevel },
      valueType,
      alias,
      isGlobal,
    } = povItem;
    //  当前pov对应的默认值
    // 如果defaultValue存在配置的默认值则取defaultValue字段值,如果不存在则取第一项下拉值,
    if (!multiLevel) {
      newInitPovValue[alias] = defaultValue;
    }
    if (valueType === 8 && multiLevel) {
      hierarchicalIdentification = true;
      // 如果是维度类型且是分层结构
      // 存储各层级的默认值
      multipleLevelInfo.forEach((levelItem: any, index: number) => {
        newInitPovValue[`${alias}!${index}`] =
          levelItem.pls.length !== 0 ? levelItem.pls[0].n : 'AllResult';
      });
    }

    povExtraAttributes[alias] = {
      // 是否是分层结构
      hierarchicalIdentification,
      // 编辑数据保存时如果is属性为1则该pov选项值编辑保存时不带
      is: 0,
      // 编辑数据保存时如果v属性为2则该pov选项值编辑保存时不带
      v: 0,
      // 是否是多选,true:多选 false:单选
      multipleChoice: false,
      // 属性维的标识
      adn: '',
      // true:当前pov刷新的时候要做全局联动
      g: !!isGlobal,
      // true:当前pov是维度树结构
      tr: false,
      // 维度树得key值,为了联动得时候被联动重置赋值得维度树重新初始化
      key: alias,
      // pov的下拉列表
      dataList: [],
    };
  });

  return {
    newInitPovValue,
    povExtraAttributes,
  };
};

/**
 * 记录每个sheet有多少行pov,当前sheet pov展开收缩状态,高度,刷新状态
 */
export const recordHowManyRowsOfPov = (
  pageList: unknown[],
  numberOfPovInARow: number,
): PovNumAndStatus => {
  let povNumAndStatus: any = {};
  let refreshResetBtnIndex = -1;
  // 当前sheet的显示出来的pov总数
  let povNum = 0;
  (pageList || []).forEach((povItem: any) => {
    const {
      valueTypeMap: { valueType, multipleLevelInfo, multiLevel },
      isDisplay,
      comparator,
    } = povItem;
    if (isDisplay) {
      // 如果是日期范围选择器占两个pov位置, 如果是多层级结构,则加上多层级结构的分层数量，否则其他pov都是1
      povNum +=
        valueType === 11 && comparator === ComparatorType.BETWEEN_AND
          ? 2
          : valueType === 8 && multiLevel
          ? (multipleLevelInfo || []).length
          : 1;
    }

    // 如果当前pov的所计数量等于一行pov能显示的总数量,则获取到刷新重新按钮渲染所在下标(记录多行pov或者恰好一行整pov的时候,刷新重置按钮所要渲染的位置)
    if (povNum === numberOfPovInARow) {
      refreshResetBtnIndex = numberOfPovInARow - 1;
    }
  });

  // 正好pov 一行能展示完
  const isEqual = povNum === numberOfPovInARow;
  // pov是否超出一行
  const isOverflow = povNum > numberOfPovInARow;

  // 对应sheet有几行pov
  const povRowNum = Math.ceil((povNum + (isEqual ? 0 : 1)) / numberOfPovInARow);
  povNumAndStatus = {
    // 默认是收起
    expand: false,
    // 对应sheet pov所占行数
    // +1是因为展开收起,刷新,重置按钮也需要占一个pov的位置
    povRowNum,
    isOverflow,
    // 对应sheet pov的高度
    height: getPovTotalHeight(povRowNum, 1),
    // 刷新重置按钮所在的位置下标索引
    butPovLocationIndex: povNum % numberOfPovInARow,
    refreshResetBtnIndex,
    // 是否需要刷新
    needToRefresh: false,
    povNum,
    isEqual,
  };
  return povNumAndStatus;
};

/**
 * 获取pov条件数据(处理分层结构数据)
 * @param povForm 当前pov的form对象
 * @param povExtraParameters pov额外属性参数
 */
export const getListPovConditionData = (
  povForm: FormInstance,
  povExtraParameters: PovExtraAttribute | Record<string, unknown>,
) => {
  // 获取对应sheet的pov筛选条件
  const povData = povForm.getFieldsValue() || {};
  // 获取对应sheet pov的所有相关额外属性
  const extraParameterObj = povExtraParameters;
  // 分层结构的pov选中数据对象
  const hierarchicalPovData: {
    [key: string]: string[];
  } = {};
  // 经过处理之后新的当前sheet下对应的所有pov筛选条件数据对象
  const newPovData = {};
  Object.keys(povData).forEach((povDataItem) => {
    // hierarchicalIdentification:是否是分层结构
    const { hierarchicalIdentification } = extraParameterObj[povDataItem.split('!')[0]];
    if (hierarchicalIdentification) {
      // 否则如果没有属性维且是分层结构
      // dimensionId:分层结构的唯一标识 hierarchicalIndex:当前属性分层所位于那个pov分层结构中的位置
      const [dimensionId, hierarchicalIndex] = povDataItem.split('!');
      // 如果存储分层结构数据对象没有该pov属性的数据数组,则声明一个数组
      if (!hierarchicalPovData[dimensionId]) {
        hierarchicalPovData[dimensionId] = [];
      }
      // 存储值
      hierarchicalPovData[dimensionId][hierarchicalIndex] = povData[povDataItem];
    } else {
      // 否则仅仅是单选结构
      newPovData[povDataItem] = povData[povDataItem];
    }
  });

  // 遍历多层级存储的数据
  Object.keys(hierarchicalPovData).forEach((attr) => {
    const newHierarchicalPovDataArr = hierarchicalPovData[attr].reverse();
    newHierarchicalPovDataArr.some((element) => {
      if (element !== 'AllResult') {
        newPovData[attr] = element;
        return true;
      }
      return false;
    });
  });
  return newPovData;
};

// 根据不同布局获取获取pov 间距 和 类名
export function getGapByLayout(layout: number) {
  if (layout === 1) {
    return {
      rowPadding: 10,
      povLayout: 'povHeightSmall',
      povSize: 28,
      // pov 未展开时,只有一组pov时高度
      povGroupHeight: 44,
      povGap: 12,
    };
  }
  if (layout === 3) {
    return {
      rowPadding: 18,
      povLayout: 'povHeightBig',
      povSize: 28,
      // pov 未展开时,只有一组pov时高度
      povGroupHeight: 60,
      povGap: 12,
    };
  }
  return {
    rowPadding: 12,
    povLayout: 'povHeightMiddle',
    povSize: 28,
    // pov 未展开时,只有一组pov时高度
    povGroupHeight: 52,
    povGap: 12,
  };
}

function getPovTotalHeight(povRowNum: number, layoutType: number | string) {
  const { rowPadding, povGap, povSize } = getGapByLayout(Number(layoutType));
  return povRowNum * povSize + povGap * (povRowNum - 1) + rowPadding * 2 + 6;
}

/**
 * 格式化pov参数
 */
export const toArrayData = <T extends string | number>(data: Record<string, T | T[]>) => {
  const newData = {};
  Object.keys(data || {}).forEach((key) => {
    const val = data[key];
    newData[key] = Array.isArray(val) ? val : val || val === 0 ? [val] : [];
  });
  return newData;
};
